from ninja import NinjaAPI, Router
from ninja.files import UploadedFile
from ninja import Form, File

# from ninja.security import BaseAuth
from django.http import HttpRequest
from typing import Optional, Dict, Any
from . import services
from django.conf import settings

# from .thinking_process import ThinkingStepType  # 已移除
from .schemas import (
    RegisterIn,
    RegisterOut,
    LoginIn,
    LoginOut,
    ChatIn,
    ChatOut,
    HistoryOut,
    ErrorResponse,
    RegenerateIn,
    RegenerateOut,
    UserInfo,
    UserListOut,
    UserUpdateIn,
    UserUpdateOut,
    UserDeleteOut,
    ChatHistoryItem,
    ChatHistoryOut,
    ChatHistoryFilter,
    AnalyticsDataOut,
    FeedbackIn,
    FeedbackOut,
    SessionInfo,
    SessionListOut,
)
from .models import APIKey, User, ConversationSession
from .services import (
    get_or_create_session,
    deepseek_r1_api_call,
    get_cached_reply,
    set_cached_reply,
    generate_session_name,
)
from .jwt_utils import generate_jwt_token, verify_jwt_token
from .schemas import LoginIn, LoginOut, ChatIn, ChatOut, HistoryOut, ErrorResponse
from .file_processors import extract_text_from_upload
from datetime import datetime, timezone, timedelta
import logging
import re

logger = logging.getLogger(__name__)


def filter_recent_conversations(context: str, max_rounds: int = 3) -> str:
    """
    过滤历史记录，只保留最近几轮对话，避免历史污染
    max_rounds: 保留的对话轮数（用户+回复算一轮）
    """
    if not context.strip():
        return ""

    # 按时间戳分割对话
    lines = context.strip().split("\n")
    conversations = []
    current_conversation = []

    for line in lines:
        # 检查是否是带时间戳的新消息
        if re.match(r"^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] (用户：|回复：)", line):
            # 保存前一个对话
            if current_conversation:
                conversations.append("\n".join(current_conversation))
            # 开始新对话
            current_conversation = [line]
        else:
            # 续行内容
            if current_conversation:
                current_conversation.append(line)

    # 保存最后一个对话
    if current_conversation:
        conversations.append("\n".join(current_conversation))

    # 只保留最近的几轮对话
    if len(conversations) <= max_rounds:
        return "\n".join(conversations)

    # 保留最近几轮，并添加提示
    recent_conversations = conversations[-max_rounds:]
    filtered_context = "\n".join(recent_conversations)

    # 添加过滤提示（可选）
    # filtered_context = f"[历史记录已过滤，只保留最近{max_rounds}轮对话]\n" + filtered_context

    return filtered_context


def build_deep_system_role() -> str:
    """构建深度思考模式的系统角色"""
    return """你是一个严谨的数据分析与诊断专家代理。

核心能力：
- 将复杂问题拆解为可验证的分析步骤
- 自主决定何时调用工具获取信息
- 基于证据进行多角度推理和验证

工具使用策略（ReAct循环）：
1. THINK: 内部分析当前情况，决定下一步行动
2. ACTION: 内部调用合适的工具获取信息
3. OBSERVATION: 内部分析工具返回的结果
4. 重复上述循环，直到获得足够信息

重要：工具调用过程对用户透明，不要输出任何工具调用指令或过程

推理要求：
- 内部进行深度思考，但不要输出思考过程
- 考虑多种可能性和解释
- 交叉验证关键假设
- 识别不确定性和风险点

输出要求：
- 直接给出最终的分析结果和解决方案
- 包含具体的代码示例和操作步骤
- 说明关键假设和不确定性
- 提供后续验证建议
- 在最后提供简洁的总结
- 不要显示"let's think step by step"等推理过程

格式规范：
- 使用统一的Markdown格式
- 标题使用 ## 或 ### 开头，不要缩进
- 代码块使用 ``` 包围
- 列表使用 - 开头，保持左对齐
- 确保所有内容都从行首开始，不要有多余的空格"""


def build_shallow_system_role() -> str:
    """构建浅层模式的系统角色"""
    return """你是一个高效的数据分析与诊断专家。

核心能力：
- 快速识别问题核心
- 必要时调用工具获取关键信息
- 提供简洁实用的解决方案

推理策略：
- 内部进行简要推理，但不要输出推理过程
- 优先使用已有知识，必要时调用工具
- 重点关注最可能的解决方案

输出要求：
- 直接给出简洁的回答和解决方案
- 包含关键步骤和代码示例
- 提供实用的解决建议
- 在最后提供简洁的总结
- 不要显示"let's think step by step"等推理过程

格式规范：
- 使用统一的Markdown格式
- 标题使用 ## 或 ### 开头，不要缩进
- 代码块使用 ``` 包围
- 列表使用 - 开头，保持左对齐
- 确保所有内容都从行首开始，不要有多余的空格"""


def _process_chat_request(
    session,
    user_input: str,
    mode: str,
    file_section: str = "",
    attachment_name: str = None,
    session_id: str = "default_session",
    user=None,
):
    """
    通用的聊天处理逻辑
    被普通聊天接口和带文件聊天接口共同使用
    """
    # 根据模式调整提示词策略和工具使用
    if mode == "deep":
        # 深度思考模式：ReAct + CoT + 多轮工具调用
        system_role = build_deep_system_role()
        max_tool_rounds = 2  # 减少到2轮，避免超时
    else:
        # 浅层模式：简单CoT + 少量工具调用
        system_role = build_shallow_system_role()
        max_tool_rounds = 1

    # 历史上下文（使用过滤后的历史记录，只保留最近几轮对话）
    raw_context = session.context
    # 根据模式调整保留的对话轮数：深度模式保留更多历史，浅层模式保留较少
    max_rounds = 5 if mode == "deep" else 2
    pure_context = filter_recent_conversations(raw_context, max_rounds=max_rounds)
    print(
        f"历史记录过滤: 原始{len(raw_context)}字符 -> 过滤后{len(pure_context)}字符 (保留{max_rounds}轮)"
    )

    # 构建工具信息
    from .tools import list_tools

    available_tools = list_tools()
    tools_info = "\n".join(
        [f"- {tool['name']}: {tool['description']}" for tool in available_tools]
    )

    # 最终提示组装
    prompt = f"""[System]
{system_role}

[Available Tools]
{tools_info}

[History]
{pure_context}

[User]
{user_input}{file_section}

请根据上述信息进行分析，必要时使用工具获取更多信息。最多可进行{max_tool_rounds}轮工具调用。

重要：请直接给出最终的分析结果和解决方案，不要显示推理过程（如"let's think step by step"、"工具使用评估"等），也不要输出任何工具调用指令（如"retrieve_logs"、"ACTION:"等）。工具调用过程对用户完全透明。

格式要求：使用标准Markdown格式，标题从行首开始（## 或 ###），不要缩进，确保格式统一美观。请在最后提供简洁的总结。

回复："""

    # 问题分析

    # 调用大模型（支持ReAct工具链）
    # 获取缓存时传入session_id和user
    cached_reply = get_cached_reply(prompt, session_id, user)

    if cached_reply:
        reply = cached_reply
        retrieval_stats = {"cached": True}
        # 缓存命中
    else:
        # 使用ReAct工具链进行推理，传递对话上下文
        try:
            # 开始推理分析
            reply = execute_react_chain(
                prompt, user_input, max_tool_rounds, pure_context
            )
            print(f"🔍 [Chat] ReAct返回长度: {len(reply) if reply else 0}")

            # 检查回复是否有效
            if not reply or not reply.strip():
                print(f"❌ [Chat] ReAct返回空回复")
                reply = "抱歉，我无法处理您的请求，请重试。"

            # 设置缓存时传入session_id和user
            set_cached_reply(prompt, reply, session_id, user)

        except Exception as e:
            print(f"❌ [Chat] ReAct执行异常: {e}")
            reply = f"抱歉，处理请求时出现错误: {str(e)}"
            # 推理过程异常

    # 保存上下文到会话（更新历史记录）
    # 添加真实时间戳到历史记录中（使用北京时间 UTC+8）
    beijing_tz = timezone(timedelta(hours=8))
    current_time = datetime.now(beijing_tz).strftime("%Y-%m-%d %H:%M:%S")

    print(f"🔍 [Chat] 准备保存历史记录，当前长度: {len(session.context)}")
    print(f"🔍 [Chat] 新回复长度: {len(reply)}")

    try:
        # 构建用户输入显示内容（包含文件信息）
        user_display = user_input
        if attachment_name:
            user_display += f"\n\n[已附加文件：{attachment_name}]"

        new_entry = (
            f"[{current_time}] 用户：{user_display}\n[{current_time}] 回复：{reply}\n"
        )
        session.context += new_entry

        # 限制历史记录长度，避免数据库性能问题
        max_context_length = 50000  # 50KB限制
        if len(session.context) > max_context_length:
            print(
                f"⚠️ [Chat] 历史记录过长({len(session.context)}字符)，截断到{max_context_length}字符"
            )
            # 保留最新的内容
            session.context = session.context[-max_context_length:]

        print(f"🔍 [Chat] 更新后历史记录长度: {len(session.context)}")

        # 检查数据库连接
        from django.db import connection

        if connection.connection is None:
            print(f"⚠️ [Chat] 数据库连接已断开，尝试重连")
            connection.connect()

        session.save()  # 持久化到数据库
        print(f"✅ [Chat] 历史记录保存成功")
    except Exception as e:
        print(f"❌ [Chat] 保存历史记录失败: {e}")
        # 即使保存失败，也要返回回复
        import traceback

        print(f"❌ [Chat] 保存异常详情: {traceback.format_exc()}")

    # 分析完成

    print(f"🔍 [Chat] 准备返回响应，回复长度: {len(reply)}")

    response_data = {
        "reply": reply,
        # 前端需要的时间戳由前端生成，后端可返回当前北京时间供参考
        "timestamp": datetime.now(beijing_tz).strftime("%H:%M:%S"),
        # 返回检索统计信息（用于调试和监控）
        # "retrieval_stats": retrieval_stats
    }

    print(f"✅ [Chat] 响应准备完成，即将返回")
    return response_data


def _parse_tool_parameters(params_str: str) -> Dict[str, Any]:
    """解析工具参数"""
    import json
    import re

    params = {}
    if not params_str.strip():
        return params

    # 尝试解析JSON格式参数
    try:
        # 处理单引号转双引号
        json_str = params_str.replace("'", '"')
        params = json.loads(json_str)
        return params
    except:
        pass

    # 尝试解析键值对格式
    try:
        # 匹配 key="value" 或 key=value 格式
        pattern = r"(\w+)=([^,]+)"
        matches = re.findall(pattern, params_str)

        for key, value in matches:
            # 去除引号
            value = value.strip().strip('"').strip("'")
            # 尝试转换为数字
            if value.isdigit():
                params[key] = int(value)
            elif value.lower() in ["true", "false"]:
                params[key] = value.lower() == "true"
            else:
                params[key] = value

        return params
    except:
        pass

    # 如果都失败，将整个字符串作为query参数
    return {"query": params_str.strip().strip('"').strip("'")}


def clean_tool_calls_from_response(response: str) -> str:
    """
    清理响应中的工具调用相关内容，只保留最终结果
    """
    import re

    # 移除工具调用指令
    cleaned = re.sub(r"ACTION:\s*\w+\s*\([^)]*\)", "", response)

    # 移除工具调用相关的文本
    cleaned = re.sub(r"让我先检索相关日志信息\.", "", cleaned)
    cleaned = re.sub(r"基于日志分析\.\.\.", "", cleaned)
    cleaned = re.sub(r"复制", "", cleaned)

    # 移除多余的空行
    cleaned = re.sub(r"\n\s*\n", "\n", cleaned)

    # 清理开头和结尾的空白
    cleaned = cleaned.strip()

    return cleaned


def execute_react_chain(
    initial_prompt: str,
    user_input: str,
    max_rounds: int,
    conversation_context: str = None,
    temperature: float = 0.7,
) -> str:
    """
    执行ReAct工具链：Reasoning + Acting + Observing
    增强版：集成新的工具调用系统
    """
    from .tools import call_tool
    from tool_system.integration import get_tool_manager, process_with_tools
    import re

    current_prompt = initial_prompt
    conversation_history = []

    for round_num in range(max_rounds):
        print(f"🔄 [ReAct] 第{round_num + 1}轮推理")

        # 思考过程步骤已移除

        # 增强提示词，包含工具调用能力
        enhanced_prompt = f"""
        {current_prompt}
        
        **可用工具**: amap_geocoding, amap_weather, amap_poi, google_search, 
                     stackoverflow_search, github_search, parse_logs, count_errors, analyze_time_patterns
        
        **工具调用说明**: 如果需要调用工具，请使用格式：ACTION: tool_name(parameters)
        
        **示例**:
        - ACTION: amap_geocoding(address="北京市天安门", city="北京")
        - ACTION: amap_weather(city="北京", extensions="all")
        - ACTION: google_search(query="Python错误解决方案", num_results=5)
        """

        # 调用大模型进行推理
        try:
            response = deepseek_r1_api_call(
                enhanced_prompt,
                user_input,
                conversation_context,
                session_id="default",
                user_id="anonymous",
                temperature=temperature,
            )
            print(f"🔍 [ReAct] API返回长度: {len(response) if response else 0}")
            conversation_history.append(f"第{round_num + 1}轮回复: {response}")

            # 检查响应是否有效
            if not response or not response.strip():
                print(f"❌ [ReAct] API返回空响应")
                return "抱歉，我无法处理您的请求，请重试。"

        except Exception as e:
            print(f"❌ [ReAct] API调用异常: {e}")
            return f"抱歉，处理请求时出现错误: {str(e)}"

        # 检查是否需要调用工具
        tool_call_match = re.search(r"ACTION:\s*(\w+)\s*\((.*?)\)", response)
        if not tool_call_match:
            # 没有工具调用，清理响应内容并返回结果
            cleaned_response = clean_tool_calls_from_response(response)
            print(f"✅ [ReAct] 完成推理，无需工具调用")
            return cleaned_response

        tool_name = tool_call_match.group(1)
        tool_params_str = tool_call_match.group(2)

        print(f"🔧 [ReAct] 调用工具: {tool_name}")

        # 工具调用步骤

        # 解析工具参数
        try:
            tool_params = _parse_tool_parameters(tool_params_str)
        except Exception as e:
            print(f"❌ [ReAct] 工具参数解析失败: {e}")
            return response

        # 调用新工具系统
        try:
            tool_manager = get_tool_manager()
            tool_result = tool_manager.execute_tool(tool_name, tool_params)

            if tool_result.success:
                observation = f"OBSERVATION: {tool_result.data}"
                print(f"👁️  [ReAct] 工具结果: {str(tool_result.data)[:100]}...")
            else:
                observation = f"OBSERVATION: 工具执行失败 - {tool_result.error}"
                print(f"❌ [ReAct] 工具执行失败: {tool_result.error}")

            # 工具调用完成

            # 更新prompt，加入工具结果
            current_prompt += f"\n\n{response}\n{observation}\n\n请基于工具结果继续分析，直接给出最终结果，不要显示推理过程："

        except Exception as e:
            print(f"❌ [ReAct] 工具调用失败: {e}")
            # 工具调用失败
            return response

    # 达到最大轮数，返回最终结果
    print(f"⚠️  [ReAct] 达到最大轮数({max_rounds})，结束工具调用")
    cleaned_response = clean_tool_calls_from_response(response)
    return cleaned_response


api = NinjaAPI(title="DeepSeek-KAI API", version="0.0.1")

# class ApiKeyAuth(AuthBase):
# def authenticate(self, request):
# auth_header = request.headers.get("Authorization")
# if not auth_header:
# return None  # 未提供认证信息，返回None表示认证失败

# try:
# # 解析 Authorization 头（格式：Bearer <api_key>）
# scheme, key = auth_header.split()
# if scheme.lower() != "bearer":
# return None  # 认证方案不是Bearer，失败

# # 查询对应的APIKey对象（验证有效性）
# api_key = APIKey.objects.get(key=key)
# # 返回APIKey对象（而非字符串），后续可通过request.auth访问
# return api_key
# except (ValueError, APIKey.DoesNotExist):
# # 解析失败或APIKey不存在，返回None表示认证失败
# return None


def jwt_auth(request):
    """验证请求头中的JWT令牌"""
    auth_header = request.headers.get("Authorization")
    if not auth_header:
        return None  # 未提供认证信息

    try:
        # 解析格式：Bearer <jwt_token>
        scheme, token = auth_header.split()
        if scheme.lower() != "bearer":
            return None  # 认证方案错误

        # 验证JWT令牌
        payload = verify_jwt_token(token)
        if not payload:
            return None  # 令牌无效或已过期

        # 获取用户
        user = User.objects.get(id=payload["user_id"], is_active=True)
        return user  # 认证成功，返回User对象
    except (ValueError, User.DoesNotExist, KeyError):
        return None  # 解析失败或用户不存在


router = Router(auth=jwt_auth)


@api.post("/register", response={200: RegisterOut, 400: ErrorResponse})
def register(request, data: RegisterIn):
    """
    注册接口：创建新用户账号
    """
    username = data.username.strip()
    password = data.password.strip()
    email = data.email.strip() if data.email else None

    # 验证输入
    if not username or not password:
        return 400, {"error": "用户名和密码不能为空"}

    if len(username) < 3:
        return 400, {"error": "用户名长度至少3个字符"}

    if len(password) < 6:
        return 400, {"error": "密码长度至少6个字符"}

    # 检查用户名是否已存在
    if User.objects.filter(username=username).exists():
        return 400, {"error": "用户名已存在"}

    # 创建新用户
    try:
        user = User(username=username, email=email)
        user.set_password(password)  # 自动哈希密码
        user.save()

        logger.info(f"新用户注册成功: {username}")
        return {"message": "注册成功", "username": username}
    except Exception as e:
        logger.error(f"注册失败: {e}")
        return 400, {"error": "注册失败，请稍后重试"}


@api.post("/login", response={200: LoginOut, 400: ErrorResponse, 403: ErrorResponse})
def login(request, data: LoginIn):
    """
    登录接口：验证用户名和密码，返回JWT令牌
    """
    username = data.username.strip()
    password = data.password.strip()

    if not username or not password:
        return 400, {"error": "用户名和密码不能为空"}

    # 查找用户
    try:
        user = User.objects.get(username=username)
    except User.DoesNotExist:
        return 403, {"error": "用户名或密码错误"}

    # 验证密码
    if not user.check_password(password):
        return 403, {"error": "用户名或密码错误"}

    # 检查用户是否激活
    if not user.is_active:
        return 403, {"error": "账号已被禁用"}

    # 更新最后登录时间
    user.update_last_login()

    # 生成JWT令牌
    token = generate_jwt_token(user.id, user.username)

    logger.info(f"用户登录成功: {username}")

    # 获取JWT过期时间配置
    from .jwt_utils import JWT_EXPIRY_SECONDS

    return {
        "token": token,
        "username": user.username,
        "user_id": user.id,
        "expiry": JWT_EXPIRY_SECONDS,
    }


@router.post("/chat", response={200: ChatOut, 401: ErrorResponse})
def chat(request, data: ChatIn):
    # 1. 认证验证（确保用户已登录）
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 解析参数（确保 session_id 有效）
    session_id = data.session_id.strip() or "default_session"
    user_input = data.user_input.strip()
    mode = (data.mode or "shallow").strip().lower()
    # 调试信息
    print(f"用户输入: {user_input}, 模式: {mode}")
    if not user_input:
        return 400, {"error": "请输入消息内容"}

    # 3. 获取会话（加载旧会话或创建新会话）
    user = request.auth  # 从认证获取当前用户（User对象）
    # 为了兼容现有的会话系统，创建或获取一个APIKey对象
    # 临时方案：使用user_id作为关联
    session = get_or_create_session(session_id, user)

    # 如果是新会话且没有会话名称，生成会话名称
    if not session.session_name and not session.context:
        try:
            session.session_name = generate_session_name(user_input)
            session.save(update_fields=["session_name"])
            print(f"✅ 生成会话名称: {session.session_name}")
        except Exception as e:
            print(f"⚠️ 生成会话名称失败: {e}")

    # 思考过程管理器已移除

    # 4. 拼接上下文（历史记录 + 当前输入）→ 关键！
    # 若 session.context 不为空，说明是旧会话（带历史）
    # 从session获取纯净的对话历史（仅用户输入和回复）
    pure_context = session.context

    # TODO RAG提示部分

    # 4. 根据模式调整提示词策略和工具使用
    if mode == "deep":
        # 深度思考模式：ReAct + CoT + 多轮工具调用
        system_role = build_deep_system_role()
        max_tool_rounds = 2  # 减少到2轮，避免超时
    else:
        # 浅层模式：简单CoT + 少量工具调用
        system_role = build_shallow_system_role()
        max_tool_rounds = 1

    # 历史上下文（使用过滤后的历史记录，只保留最近几轮对话）
    raw_context = session.context
    # 根据模式调整保留的对话轮数：深度模式保留更多历史，浅层模式保留较少
    max_rounds = 5 if mode == "deep" else 2
    pure_context = filter_recent_conversations(raw_context, max_rounds=max_rounds)
    print(
        f"历史记录过滤: 原始{len(raw_context)}字符 -> 过滤后{len(pure_context)}字符 (保留{max_rounds}轮)"
    )

    # 5. 构建工具信息
    from .tools import list_tools

    available_tools = list_tools()
    tools_info = "\n".join(
        [f"- {tool['name']}: {tool['description']}" for tool in available_tools]
    )

    # 6. 调用通用的聊天处理逻辑
    return _process_chat_request(
        session=session,
        user_input=user_input,
        mode=mode,
        file_section="",  # 普通聊天没有文件内容
        attachment_name=None,  # 普通聊天没有附件
        session_id=session_id,
        user=user,
    )


# 1. 修复 history 接口
@router.get("/history", response={200: HistoryOut})
def history(request, session_id: str = "default_session"):
    """查看对话历史接口：根据session_id返回对话历史"""
    # 直接使用 session_id 参数，无需通过 data
    processed_session_id = session_id.strip() or "default_session"
    user = request.auth  # User对象
    session = services.get_or_create_session(processed_session_id, user)
    return {"history": session.context}


# 2. 修复 clear_history 接口
@router.delete("/history", response={200: dict})
def clear_history(request, session_id: str = "default_session"):
    """清空对话历史接口"""
    # 直接使用 session_id 参数，无需通过 data
    processed_session_id = session_id.strip() or "default_session"
    user = request.auth  # User对象
    session = services.get_or_create_session(processed_session_id, user)
    session.clear_context()
    return {"message": "历史记录已清空"}


# 3. 删除会话接口
@router.delete("/session", response={200: dict, 404: ErrorResponse})
def delete_session(request, session_id: str):
    """删除会话接口 - 完全删除会话记录"""
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    processed_session_id = session_id.strip()
    if not processed_session_id:
        return 400, {"error": "会话ID不能为空"}

    user = request.auth  # User对象

    try:
        # 查找会话
        session = ConversationSession.objects.filter(
            session_id=processed_session_id, user=user
        ).first()

        if not session:
            return 404, {"error": "会话不存在"}

        # 删除会话
        session.delete()
        logger.info(f"用户 {user.username} 删除会话 {processed_session_id}")

        return {"message": f"会话 {processed_session_id} 已删除"}
    except Exception as e:
        logger.error(f"删除会话失败: {e}")
        return 400, {"error": f"删除会话失败: {str(e)}"}


@router.post("/chat_with_file", response={200: ChatOut, 401: ErrorResponse})
def chat_with_file(
    request,
    session_id: str = Form("default_session"),
    user_input: str = Form(""),
    mode: str = Form("shallow"),
    attachment: UploadedFile = File(None),
):
    """
    支持文件上传的聊天接口
    这个接口与普通聊天接口逻辑相同，只是在提示词中添加了文件内容
    """
    # 1. 认证验证（确保用户已登录）
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 解析参数
    session_id = session_id.strip() or "default_session"
    user_input = user_input.strip()
    mode = mode.strip().lower() or "shallow"

    # 调试信息
    print(
        f"用户输入: {user_input}, 模式: {mode}, 文件: {attachment.name if attachment else 'None'}"
    )

    if not user_input and not attachment:
        return 400, {"error": "请输入消息内容或上传文件"}

    # 3. 获取会话（加载旧会话或创建新会话）
    user = request.auth  # 从认证获取当前用户（User对象）
    session = get_or_create_session(session_id, user)

    # 如果是新会话且没有会话名称，生成会话名称
    if not session.session_name and not session.context:
        try:
            # 如果有用户输入，使用用户输入；否则使用文件名
            name_source = (
                user_input
                if user_input
                else (f"文件分析：{attachment.name}" if attachment else "新会话")
            )
            session.session_name = generate_session_name(name_source)
            session.save(update_fields=["session_name"])
            print(f"✅ 生成会话名称: {session.session_name}")
        except Exception as e:
            print(f"⚠️ 生成会话名称失败: {e}")

    # 4. 处理文件内容
    file_content = ""
    if attachment:
        try:
            file_content = extract_text_from_upload(attachment)
            print(f"文件内容长度: {len(file_content)}")
        except Exception as e:
            print(f"文件处理失败: {e}")
            return 400, {"error": f"文件处理失败: {str(e)}"}

    # 5. 构建文件内容部分（如果有文件的话）
    file_section = ""
    if file_content:
        file_section = f"\n[Attached File Content]\n{file_content}\n"

    # 6. 调用通用的聊天处理逻辑
    return _process_chat_request(
        session=session,
        user_input=user_input,
        mode=mode,
        file_section=file_section,
        attachment_name=attachment.name if attachment else None,
        session_id=session_id,
        user=user,
    )


@router.post(
    "/upload_log",
    response={200: dict, 400: ErrorResponse, 401: ErrorResponse, 403: ErrorResponse},
)
def upload_log(request, file: UploadedFile = File(...)):
    """
    上传日志文件接口（仅管理员可用）
    将上传的日志文件保存到/data/log目录，并更新向量数据库
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以上传文件扩充知识库"}

    # 3. 验证文件
    if not file:
        return 400, {"error": "请选择要上传的文件"}

    # 检查文件类型（允许常见的日志文件格式）
    allowed_extensions = [".log", ".txt", ".csv", ".json"]
    file_extension = None
    if "." in file.name:
        file_extension = "." + file.name.split(".")[-1].lower()

    if file_extension not in allowed_extensions:
        return 400, {
            "error": f"不支持的文件类型。支持的类型: {', '.join(allowed_extensions)}"
        }

    # 检查文件大小（限制为10MB）
    max_size = 10 * 1024 * 1024  # 10MB
    if file.size > max_size:
        return 400, {"error": "文件大小不能超过10MB"}

    try:
        # 4. 保存文件到/data/log目录
        import os
        from django.conf import settings

        # 确保目录存在
        log_dir = "./data/log"
        os.makedirs(log_dir, exist_ok=True)

        # 生成唯一的文件名（避免覆盖）
        import uuid
        from datetime import datetime

        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        unique_id = str(uuid.uuid4())[:8]
        safe_filename = f"{timestamp}_{unique_id}_{file.name}"
        file_path = os.path.join(log_dir, safe_filename)

        # 保存文件
        with open(file_path, "wb") as destination:
            for chunk in file.chunks():
                destination.write(chunk)

        # 5. 更新向量数据库
        from .services import update_vector_database_with_file

        update_result = update_vector_database_with_file(file_path, file.name)

        logger.info(f"管理员 {user.username} 上传文件成功: {safe_filename}")

        return {
            "message": "日志文件上传成功",
            "filename": safe_filename,
            "file_path": file_path,
            "vector_update": update_result,
        }

    except Exception as e:
        logger.error(f"日志文件上传失败: {e}")
        return 400, {"error": f"文件上传失败: {str(e)}"}


@router.post("/regenerate", response={200: RegenerateOut, 401: ErrorResponse})
def regenerate(request, data: RegenerateIn):
    """
    重新生成最后一次AI回复
    从历史记录中提取最后一次用户输入，重新生成回复
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 解析参数
    session_id = data.session_id.strip() or "default_session"
    mode = (data.mode or "shallow").strip().lower()

    # 3. 获取会话
    user = request.auth
    session = get_or_create_session(session_id, user)

    # 4. 从历史记录中提取最后一次用户输入
    # 历史记录格式：[2025-10-13 14:05:30] 用户：xxx\n[2025-10-13 14:05:31] 回复：yyy
    lines = session.context.strip().split("\n")

    # 从后往前找到最后一条"用户："开头的内容
    last_user_input = None
    for line in reversed(lines):
        if "用户：" in line:
            # 提取用户输入（去掉时间戳和"用户："前缀）
            match = re.search(r"用户：(.*)$", line)
            if match:
                last_user_input = match.group(1).strip()
                break

    if not last_user_input:
        return 400, {"error": "找不到之前的用户输入，无法重新生成"}

    print(f"重新生成 - 用户输入: {last_user_input}, 模式: {mode}")

    # 5. 获取历史上下文（不包括最后一次对话）
    raw_context = session.context
    max_rounds = 5 if mode == "deep" else 2

    # 移除最后一次对话（用户和AI回复）
    lines = raw_context.strip().split("\n")
    filtered_lines = []
    last_conversation_count = 0

    for line in reversed(lines):
        if "[回复：" in line:
            last_conversation_count += 1
        elif "用户：" in line:
            last_conversation_count += 1

        if last_conversation_count < 2:
            filtered_lines.insert(0, line)

    # 获取去掉最后一次对话的历史记录
    modified_context = "\n".join(filtered_lines)
    pure_context = filter_recent_conversations(modified_context, max_rounds=max_rounds)

    print(
        f"重新生成 - 历史记录过滤: 原始{len(raw_context)}字符 -> 过滤后{len(pure_context)}字符"
    )

    # 6. 根据模式调整提示词策略和工具使用
    if mode == "deep":
        system_role = build_deep_system_role()
        max_tool_rounds = 2
    else:
        system_role = build_shallow_system_role()
        max_tool_rounds = 1

    # 7. 构建工具信息
    from .tools import list_tools

    available_tools = list_tools()
    tools_info = "\n".join(
        [f"- {tool['name']}: {tool['description']}" for tool in available_tools]
    )

    # 8. 构建提示（添加重新生成的特殊指示）
    import time

    regenerate_timestamp = time.time()
    prompt = f"""[System]
{system_role}

[Available Tools]
{tools_info}

[History]
{pure_context}

[User]
{last_user_input}

**重要：这是一个重新生成请求。请提供一个不同于之前的回答，可以从不同角度、不同侧重点或不同的表述方式来回答这个问题。创新性、多样性很重要！**

请根据上述信息进行分析，必要时使用工具获取更多信息。最多可进行{max_tool_rounds}轮工具调用。

重要：请直接给出最终的分析结果和解决方案，不要显示推理过程（如"let's think step by step"、"工具使用评估"等），也不要输出任何工具调用指令（如"retrieve_logs"、"ACTION:"等）。工具调用过程对用户完全透明。

格式要求：使用标准Markdown格式，标题从行首开始（## 或 ###），不要缩进，确保格式统一美观。请在最后提供简洁的总结。

回复："""

    # 9. 调用AI（重新生成不走缓存，使用更高的temperature来增加多样性）
    try:
        # 使用更高的temperature（0.9）来确保每次重新生成都得到不同的回答
        regenerate_temperature = 0.9
        reply = execute_react_chain(
            prompt,
            last_user_input,
            max_tool_rounds,
            pure_context,
            temperature=regenerate_temperature,
        )

        if not reply or not reply.strip():
            reply = "抱歉，我无法处理您的请求，请重试。"

        # 重新生成的回复不缓存，避免下次重新生成得到相同的答案
        print(f"✅ [Regenerate] 完成重新生成，回复长度: {len(reply)}")
    except Exception as e:
        print(f"❌ [Regenerate] 执行异常: {e}")
        reply = f"抱歉，处理请求时出现错误: {str(e)}"

    # 10. 返回新生成的回复（不更新数据库）
    beijing_tz = timezone(timedelta(hours=8))

    return {
        "reply": reply,
        "timestamp": datetime.now(beijing_tz).strftime("%H:%M:%S"),
    }


# ==================== 用户管理API接口 ====================


@router.get(
    "/admin/users", response={200: UserListOut, 401: ErrorResponse, 403: ErrorResponse}
)
def get_users(request, page: int = 1, page_size: int = 20):
    """
    获取用户列表（仅管理员可用）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以查看用户列表"}

    # 3. 分页参数验证
    page = max(1, page)
    page_size = min(max(1, page_size), 100)  # 限制最大100条

    # 4. 获取用户列表
    try:
        from django.core.paginator import Paginator

        users_queryset = User.objects.all().order_by("-created_at")
        paginator = Paginator(users_queryset, page_size)
        page_obj = paginator.get_page(page)

        users = []
        for user_obj in page_obj:
            users.append(
                UserInfo(
                    id=user_obj.id,
                    username=user_obj.username,
                    email=user_obj.email,
                    created_at=user_obj.created_at.strftime("%Y-%m-%d %H:%M:%S"),
                    updated_at=user_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S"),
                    is_active=user_obj.is_active,
                    last_login=(
                        user_obj.last_login.strftime("%Y-%m-%d %H:%M:%S")
                        if user_obj.last_login
                        else None
                    ),
                )
            )

        return {
            "users": users,
            "total": paginator.count,
            "page": page,
            "page_size": page_size,
        }

    except Exception as e:
        logger.error(f"获取用户列表失败: {e}")
        return 400, {"error": f"获取用户列表失败: {str(e)}"}


@router.get(
    "/admin/users/{user_id}",
    response={
        200: UserInfo,
        401: ErrorResponse,
        403: ErrorResponse,
        404: ErrorResponse,
    },
)
def get_user_detail(request, user_id: int):
    """
    获取用户详情（仅管理员可用）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以查看用户详情"}

    # 3. 获取用户
    try:
        user_obj = User.objects.get(id=user_id)
        return UserInfo(
            id=user_obj.id,
            username=user_obj.username,
            email=user_obj.email,
            created_at=user_obj.created_at.strftime("%Y-%m-%d %H:%M:%S"),
            updated_at=user_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S"),
            is_active=user_obj.is_active,
            last_login=(
                user_obj.last_login.strftime("%Y-%m-%d %H:%M:%S")
                if user_obj.last_login
                else None
            ),
        )
    except User.DoesNotExist:
        return 404, {"error": "用户不存在"}
    except Exception as e:
        logger.error(f"获取用户详情失败: {e}")
        return 400, {"error": f"获取用户详情失败: {str(e)}"}


@router.put(
    "/admin/users/{user_id}",
    response={
        200: UserUpdateOut,
        401: ErrorResponse,
        403: ErrorResponse,
        404: ErrorResponse,
    },
)
def update_user(request, user_id: int, data: UserUpdateIn):
    """
    更新用户信息（仅管理员可用）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以更新用户信息"}

    # 3. 获取用户
    try:
        user_obj = User.objects.get(id=user_id)
    except User.DoesNotExist:
        return 404, {"error": "用户不存在"}

    # 4. 更新用户信息
    try:
        updated_fields = []

        if data.username is not None:
            # 检查用户名是否已存在（排除当前用户）
            if User.objects.filter(username=data.username).exclude(id=user_id).exists():
                return 400, {"error": "用户名已存在"}
            user_obj.username = data.username
            updated_fields.append("username")

        if data.email is not None:
            user_obj.email = data.email
            updated_fields.append("email")

        if data.is_active is not None:
            user_obj.is_active = data.is_active
            updated_fields.append("is_active")

        if updated_fields:
            user_obj.save(update_fields=updated_fields)

        logger.info(
            f"管理员 {user.username} 更新用户 {user_obj.username} 信息: {updated_fields}"
        )

        return {
            "message": "用户信息更新成功",
            "user": UserInfo(
                id=user_obj.id,
                username=user_obj.username,
                email=user_obj.email,
                created_at=user_obj.created_at.strftime("%Y-%m-%d %H:%M:%S"),
                updated_at=user_obj.updated_at.strftime("%Y-%m-%d %H:%M:%S"),
                is_active=user_obj.is_active,
                last_login=(
                    user_obj.last_login.strftime("%Y-%m-%d %H:%M:%S")
                    if user_obj.last_login
                    else None
                ),
            ),
        }

    except Exception as e:
        logger.error(f"更新用户信息失败: {e}")
        return 400, {"error": f"更新用户信息失败: {str(e)}"}


@router.delete(
    "/admin/users/{user_id}",
    response={
        200: UserDeleteOut,
        401: ErrorResponse,
        403: ErrorResponse,
        404: ErrorResponse,
    },
)
def delete_user(request, user_id: int):
    """
    删除用户（仅管理员可用）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以删除用户"}

    # 3. 防止删除管理员账号
    if user_id == user.id:
        return 400, {"error": "不能删除管理员账号"}

    # 4. 获取用户
    try:
        user_obj = User.objects.get(id=user_id)
    except User.DoesNotExist:
        return 404, {"error": "用户不存在"}

    # 5. 删除用户
    try:
        username = user_obj.username
        user_obj.delete()

        logger.info(f"管理员 {user.username} 删除用户 {username}")

        return {"message": f"用户 {username} 删除成功"}

    except Exception as e:
        logger.error(f"删除用户失败: {e}")
        return 400, {"error": f"删除用户失败: {str(e)}"}


# ==================== 数据分析API接口 ====================


@router.get(
    "/admin/analytics",
    response={
        200: AnalyticsDataOut,
        400: ErrorResponse,
        401: ErrorResponse,
        403: ErrorResponse,
    },
)
def get_analytics_data(request):
    """
    获取数据分析统计数据（仅管理员可用）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以查看数据分析"}

    try:
        from django.db.models import Count, Q
        from datetime import datetime, timedelta

        # 总用户数
        total_users = User.objects.count()

        # 总对话数
        total_conversations = ConversationSession.objects.count()

        # 活跃用户数（最近7天有对话的用户）
        seven_days_ago = datetime.now() - timedelta(days=7)
        active_users = (
            ConversationSession.objects.filter(created_at__gte=seven_days_ago)
            .values("user")
            .distinct()
            .count()
        )

        # 总消息数（估算：每个session的context行数）
        total_messages = 0
        for session in ConversationSession.objects.all():
            if session.context:
                total_messages += len(
                    [line for line in session.context.split("\n") if line.strip()]
                )

        # 用户增长数据（最近30天）
        thirty_days_ago = datetime.now() - timedelta(days=30)
        user_growth = []
        for i in range(30):
            date = (datetime.now() - timedelta(days=29 - i)).date()
            count = User.objects.filter(created_at__date=date).count()
            user_growth.append({"date": date.strftime("%m-%d"), "count": count})

        # 对话趋势数据（最近30天）
        conversation_trend = []
        for i in range(30):
            date = (datetime.now() - timedelta(days=29 - i)).date()
            count = ConversationSession.objects.filter(created_at__date=date).count()
            conversation_trend.append({"date": date.strftime("%m-%d"), "count": count})

        # 活跃用户排行（对话数Top 10）
        top_users_data = (
            ConversationSession.objects.values("user__username")
            .annotate(conversation_count=Count("id"))
            .order_by("-conversation_count")[:10]
        )

        top_users = [
            {
                "username": item["user__username"],
                "conversation_count": item["conversation_count"],
            }
            for item in top_users_data
        ]

        # 平均每次对话的消息数
        avg_messages_per_session = (
            total_messages / total_conversations if total_conversations > 0 else 0
        )

        # 24小时活跃度分布
        hourly_activity = []
        for hour in range(24):
            count = ConversationSession.objects.filter(created_at__hour=hour).count()
            hourly_activity.append({"hour": f"{hour:02d}:00", "count": count})

        # 故障类型分布（基于对话内容关键词分析）
        fault_types = {
            "网络故障": 0,
            "系统错误": 0,
            "性能问题": 0,
            "配置错误": 0,
            "其他问题": 0,
        }

        # 简单的关键词匹配来分类故障
        for session in ConversationSession.objects.all():
            if session.context:
                context_lower = session.context.lower()
                if any(
                    keyword in context_lower
                    for keyword in ["网络", "network", "连接", "connection"]
                ):
                    fault_types["网络故障"] += 1
                elif any(
                    keyword in context_lower
                    for keyword in ["错误", "error", "异常", "exception"]
                ):
                    fault_types["系统错误"] += 1
                elif any(
                    keyword in context_lower
                    for keyword in ["慢", "slow", "性能", "performance", "延迟"]
                ):
                    fault_types["性能问题"] += 1
                elif any(
                    keyword in context_lower
                    for keyword in ["配置", "config", "设置", "setting"]
                ):
                    fault_types["配置错误"] += 1
                else:
                    fault_types["其他问题"] += 1

        # 转换为列表格式
        fault_distribution = [
            {"type": fault_type, "count": count}
            for fault_type, count in fault_types.items()
            if count > 0  # 只显示有数据的类型
        ]

        # 问题解决率趋势（真实数据）
        resolution_trend = []
        for i in range(7):  # 最近7天
            date = (datetime.now() - timedelta(days=6 - i)).date()

            # 统计当天的对话数
            daily_total = ConversationSession.objects.filter(
                created_at__date=date
            ).count()

            # 统计当天已解决的对话数（is_resolved = True）
            daily_resolved = ConversationSession.objects.filter(
                created_at__date=date, is_resolved=True
            ).count()

            # 计算解决率
            if daily_total > 0:
                resolution_rate = round((daily_resolved / daily_total) * 100, 1)
            else:
                resolution_rate = 0

            resolution_trend.append(
                {
                    "date": date.strftime("%m-%d"),
                    "rate": resolution_rate,
                    "total": daily_total,
                    "resolved": daily_resolved,
                }
            )

        return 200, {
            "total_users": total_users,
            "total_conversations": total_conversations,
            "active_users": active_users,
            "total_messages": total_messages,
            "user_growth": user_growth,
            "conversation_trend": conversation_trend,
            "top_users": top_users,
            "avg_messages_per_session": round(avg_messages_per_session, 2),
            "hourly_activity": hourly_activity,
            "fault_distribution": fault_distribution,
            "resolution_trend": resolution_trend,
        }

    except Exception as e:
        logger.error(f"获取数据分析失败: {str(e)}")
        return 400, {"error": f"获取数据分析失败: {str(e)}"}


# ==================== 对话历史API接口 ====================


@router.get(
    "/admin/chat-history",
    response={
        200: ChatHistoryOut,
        400: ErrorResponse,
        401: ErrorResponse,
        403: ErrorResponse,
    },
)
def get_chat_history(
    request,
    user_id: Optional[int] = None,
    username: Optional[str] = None,
    start_date: Optional[str] = None,
    end_date: Optional[str] = None,
    page: int = 1,
    page_size: int = 20,
):
    """
    获取对话历史（仅管理员可用）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    # 2. 管理员权限验证
    user = request.auth
    if user.username != "admin":
        return 403, {"error": "只有管理员可以查看对话历史"}

    # 3. 分页参数验证
    page = max(1, page)
    page_size = min(max(1, page_size), 100)  # 限制最大100条

    try:
        from django.core.paginator import Paginator
        from django.db.models import Q
        from datetime import datetime

        # 构建查询条件
        sessions_queryset = ConversationSession.objects.select_related("user").all()

        # 用户筛选
        if user_id:
            sessions_queryset = sessions_queryset.filter(user_id=user_id)
        elif username:
            sessions_queryset = sessions_queryset.filter(
                user__username__icontains=username
            )

        # 时间筛选
        if start_date:
            try:
                start_dt = datetime.strptime(start_date, "%Y-%m-%d")
                sessions_queryset = sessions_queryset.filter(created_at__gte=start_dt)
            except ValueError:
                return 400, {"error": "开始日期格式错误，请使用 YYYY-MM-DD 格式"}

        if end_date:
            try:
                end_dt = datetime.strptime(end_date, "%Y-%m-%d")
                sessions_queryset = sessions_queryset.filter(created_at__lte=end_dt)
            except ValueError:
                return 400, {"error": "结束日期格式错误，请使用 YYYY-MM-DD 格式"}

        # 按时间排序
        sessions_queryset = sessions_queryset.order_by("-created_at")

        # 分页
        paginator = Paginator(sessions_queryset, page_size)
        page_obj = paginator.get_page(page)

        conversations = []
        for session in page_obj:
            # 返回完整的会话内容，而不是拆分成单行
            if session.context and session.context.strip():
                try:
                    conversations.append(
                        ChatHistoryItem(
                            session_id=session.session_id,
                            user_id=session.user.id,
                            username=session.user.username,
                            content=session.context.strip(),  # 返回完整的对话内容
                            timestamp=session.created_at.strftime("%Y-%m-%d %H:%M:%S"),
                        )
                    )
                except Exception as parse_error:
                    logger.warning(
                        f"解析对话记录失败: {parse_error}, session_id={session.session_id}"
                    )
                    continue

        logger.info(
            f"获取对话历史成功: 总数={paginator.count}, 当前页={page}, 返回={len(conversations)}条"
        )

        return {
            "conversations": conversations,
            "total": paginator.count,
            "page": page,
            "page_size": page_size,
        }

    except Exception as e:
        import traceback

        error_detail = traceback.format_exc()
        logger.error(f"获取对话历史失败: {e}\n{error_detail}")
        return 400, {"error": f"获取对话历史失败: {str(e)}"}


# ==================== 用户反馈API接口 ====================


@router.post(
    "/feedback",
    response={
        200: FeedbackOut,
        401: ErrorResponse,
        404: ErrorResponse,
        400: ErrorResponse,
    },
)
def submit_feedback(request, data: FeedbackIn):
    """
    用户提交对话反馈（问题是否解决）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    user = request.auth

    try:
        # 2. 查找会话
        session = ConversationSession.objects.filter(
            session_id=data.session_id, user=user
        ).first()

        if not session:
            return 404, {"error": "会话不存在"}

        # 3. 更新反馈状态
        from django.utils import timezone

        session.is_resolved = data.is_resolved
        session.feedback_time = timezone.now()
        session.save(update_fields=["is_resolved", "feedback_time"])

        logger.info(
            f"用户 {user.username} 对会话 {data.session_id} 反馈: {'已解决' if data.is_resolved else '未解决'}"
        )

        return 200, {
            "message": "反馈提交成功",
            "session_id": data.session_id,
            "is_resolved": data.is_resolved,
        }

    except Exception as e:
        logger.error(f"提交反馈失败: {str(e)}")
        return 400, {"error": f"提交反馈失败: {str(e)}"}


# ==================== 会话管理API接口 ====================


@router.get("/sessions", response={200: SessionListOut, 401: ErrorResponse})
def get_sessions(request):
    """
    获取当前用户的所有会话列表（包含会话名称）
    """
    # 1. 认证验证
    if not request.auth:
        return 401, {"error": "请先登录获取JWT令牌"}

    user = request.auth

    try:
        # 2. 获取用户的所有会话
        sessions = ConversationSession.objects.filter(user=user).order_by("-updated_at")

        session_list = []
        for session in sessions:
            session_list.append(
                SessionInfo(
                    session_id=session.session_id,
                    session_name=session.session_name
                    or session.session_id,  # 如果没有名称，使用session_id
                    created_at=session.created_at.strftime("%Y-%m-%d %H:%M:%S"),
                    updated_at=session.updated_at.strftime("%Y-%m-%d %H:%M:%S"),
                )
            )

        return 200, {"sessions": session_list}

    except Exception as e:
        logger.error(f"获取会话列表失败: {str(e)}")
        return 400, {"error": f"获取会话列表失败: {str(e)}"}


# 将路由添加到API
api.add_router("", router)
